/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package teste;

import config.LogErro;
import controllers.AtributoAuxController;
import controllers.ProcedimentoController;
import java.sql.Date;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;
import models.dados.HibernateUtil;
import models.entidades.Procedimento;


/**
 *
 * @author Wenderson
 */
public class GeradorDados {

    public static int TAMANHO_PALAVRA = 3;
    public static int MAX_NUMERO = 50;
    public static int MIN_NUMERO = 0;
    
    /**
     * Quantidade de letras combinadas.
     */
    public static int COMBINACAO_LETRAS = 3;
    
    public enum FonteTexto {
        ALTA, BAIXA
    }
    
    private static String texto = 
            "computação definida busca solução "
          + "problema entradas resultados "
          + "depois trabalhada através algoritmo lida "
          + "teoria subcampo ciência computação matemática "
          + "Durante milhares executada caneta papel "
          + "ardósia mentalmente vezes auxílio tabelas "
          + "utensílios artesanais";
    
    private static String[] letras = {
        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "l", "m", "n", "o",
        "p", "q", "s", "t", "u", "v", "x", "z"
    };
    
    public static ArrayList<String> getPalavras(int quantidade, FonteTexto fonte) {
        Random rand = new Random();
        
        int numero = rand.nextInt(quantidade);
        
        String[] palavras = texto.split(" ");
        
        ArrayList<String> texto = new ArrayList<String>();
        
        if (quantidade > palavras.length) {
            quantidade = palavras.length;
        }
        
        for (int i = 0; i < quantidade; i++) {
            String palavra = palavras[rand.nextInt(quantidade)];
            
            palavra = palavra.length() > TAMANHO_PALAVRA ? palavra.substring(0, TAMANHO_PALAVRA) : palavra;
            
            if (!existsS(texto, palavra)) {
                if (fonte == FonteTexto.ALTA) {
                    texto.add(palavra.toUpperCase());
                } else {
                    texto.add(palavra.toLowerCase());
                }
            } else {
                i--;
            }
        }
        
        return texto;
    }
    
    public static ArrayList<String> getLetras(int quantidade, FonteTexto fonte) {
        Random rand = new Random();
        
        ArrayList<String> texto = new ArrayList<String>();
        String palavra = "";        
        
        for (int i = 0; i < quantidade; i++) {
            palavra = "";
            
            for (int j = 0; j < COMBINACAO_LETRAS; j++) {
                palavra += letras[rand.nextInt(letras.length)];
            }
            
            if (!existsS(texto, palavra)) {
                if (fonte == FonteTexto.ALTA) {
                    texto.add(palavra.toUpperCase());
                } else {
                    texto.add(palavra.toLowerCase());
                }
            } else {
                i--;
            }
        }
        
        return texto;
    }
    
    public static ArrayList<Integer> getNumerosInteiros(int quantidade) {
        Random rand = new Random();
        
        ArrayList<Integer> lista = new ArrayList<Integer>();
        
        for (int i = 0; i < quantidade; i++) {
            int numero = (MAX_NUMERO - rand.nextInt(MAX_NUMERO)) + MIN_NUMERO;
            
            if (!existsI(lista, numero)) {
                lista.add(numero);
            } else {
                i--;
            }
        }
        
        return lista;
    }
    
    public static ArrayList<Double> getNumerosFlutuantes(int quantidade) {
        Random rand = new Random();
        
        ArrayList<Double> lista = new ArrayList<Double>();
        
        int rangeMin = MIN_NUMERO;
        int rangeMax = MAX_NUMERO;
        
        for (int i = 0; i < quantidade; i++) {
            double numero = rangeMin + (rangeMax - rangeMin) * rand.nextDouble();
            numero = Math.rint(numero);
                    
            if (!existsD(lista, numero)) {
                lista.add(numero);
            } else {
                i--;
            }
        }
        
        return lista;
    }
    
    private static ArrayList<java.sql.Date> getDatas(int quantidade) {
        Random rand = new Random();
        
        ArrayList<java.sql.Date> lista = new ArrayList<Date>();
        
        for (int i = 0; i < quantidade; i++) {
            java.sql.Date data = new java.sql.Date(
                    (2000 + rand.nextInt(14)) - 1900, (1 + rand.nextInt(11)), (1 + rand.nextInt(27)));
            
            if (!existsDate(lista, data)) {
                lista.add(data);
            } else {
                i--;
            }
        }
        return lista;
    }
    
    private static boolean existsDate(ArrayList<java.sql.Date> lista, java.sql.Date data) {
            for (int i = 0; i < lista.size(); i++) {
                if (lista.get(i).equals(data)) {
                    return true;
                }
            }
            return false;
    }
    
    private static boolean existsS(ArrayList<String> lista, String palavra) {
        for (int i = 0; i < lista.size(); i++) {
            if (lista.get(i).equalsIgnoreCase(palavra)) {
                return true;
            }
        }
        return false;
    }
    
    private static boolean existsI(ArrayList<Integer> lista, int numero) {
        for (int i = 0; i < lista.size(); i++) {
            if (lista.get(i).equals(numero)) {
                return true;
            }
        }
        return false;
    }
    
    private static boolean existsD(ArrayList<Double> lista, double numero) {
        for (int i = 0; i < lista.size(); i++) {
            if (lista.get(i).equals(numero)) {
                return true;
            }
        }
        return false;
    }
    
    public static HashMap<String, ArrayList<Object>> getValores(Procedimento procedimento, HashMap<String, String> atributos, int quantidade) {
        try {// REMOVER ATRIBUTO PROCEDIMENTO
            HashMap<String, ArrayList<Object>> lista = new HashMap<String, ArrayList<Object>>();
            
            for (String atributo : atributos.keySet()) {
                // System.out.println("GET VALOR " + atributo + " = " + atributos.get(atributo));
                ArrayList resultado = getValor(atributos.get(atributo), quantidade);
                
                lista.put(atributo, resultado);
            }
            
            return lista;
        } catch (Exception e) {
            LogErro.gravaErro(e);e.printStackTrace();
        }
        return null;
    }
    
    private static ArrayList getValor(String tipo, int quantidade) {
        try {
            tipo = tipo.toUpperCase();
            
            if (tipo.equals("VARCHAR")) {
                return getPalavras(quantidade, FonteTexto.BAIXA);
            } else if (tipo.equals("CHAR")) {
                return getLetras(quantidade, FonteTexto.BAIXA);
            } else if (tipo.equals("DOUBLE") || tipo.equals("FLOAT") || 
                       tipo.equals("NUMERIC")|| tipo.equals("DECIMAL")) {
                return getNumerosFlutuantes(quantidade);
            } else if (tipo.equals("INT") || tipo.equals("INTEGER")) {
                return getNumerosInteiros(quantidade);
            } else if (tipo.equals("DATE") || tipo.equals("DATETIME")) {
                return getDatas(quantidade);
            }
            
            System.out.println("\n\n******************* NENHUM TIPO " + tipo + " *******************");
        } catch (Exception e) {
            LogErro.gravaErro(e);e.printStackTrace();
        }
        return null;
    }
    
    public static HashMap<String, ArrayList<Object>> alterarValores(HashMap<String, ArrayList<Object>> atual, String nomeAtributo, int index_inicial, int index_final) {
        try {
            for (String atributo : atual.keySet()) {
                if (atributo.equalsIgnoreCase(nomeAtributo)) {
                    //System.out.println(atributo);
                    ArrayList array = atual.get(atributo);
                 
                    for (int i = 0; i < index_final; i++) {
                        array.set(i, array.get(i + index_inicial));
                    }
                    atual.put(atributo, array);
                }
            }
            
            return atual;
        } catch (Exception e) {
            LogErro.gravaErro(e);e.printStackTrace();
        }
        return null;
    }
    
    public static HashMap<String, ArrayList<Object>> alterarValoresNull(HashMap<String, ArrayList<Object>> atual, String nomeAtributo) {
        try {
            for (String atributo : atual.keySet()) {
                if (atributo.equalsIgnoreCase(nomeAtributo)) {
                    ArrayList array = atual.get(atributo);
                    
                    for (int i = 0; i < array.size(); i++) {
                        array.set(i, null);
                    }
                    
                    atual.put(atributo, array);
                }
            }
            
            return atual;
        } catch (Exception e) {
            LogErro.gravaErro(e);e.printStackTrace();
        }
        return null;
    }
    
    public static HashMap<String, ArrayList<Object>> alterarValoresCharacter(HashMap<String, ArrayList<Object>> atual, String nomeAtributo, FonteTexto fonte) {
        try {
            for (String atributo : atual.keySet()) {
                if (atributo.equalsIgnoreCase(nomeAtributo)) {
                    ArrayList array = atual.get(atributo);
                    
                    for (int i = 0; i < array.size(); i++) {
                        if (fonte == FonteTexto.ALTA) {
                            array.set(i, array.get(i).toString().toUpperCase());
                        } else {
                            array.set(i, array.get(i).toString().toLowerCase());
                        }
                    }
                    
                    atual.put(atributo, array);
                }
            }
            
            return atual;
        } catch (Exception e) {
            LogErro.gravaErro(e);e.printStackTrace();
        }
        return null;
    }
    
    public static void main(String[] args) {
        //<editor-fold defaultstate="collapsed" desc="Teste Gerador">
//          GeradorDados gerador = new GeradorDados();
//
//        System.out.println(gerador.getPalavras(10, FonteTexto.ALTA).toString());
//        System.out.println(gerador.getLetras(10, FonteTexto.BAIXA).toString());
//        System.out.println(gerador.getNumerosInteiros(10).toString());
//        System.out.println(gerador.getNumerosFlutuantes(10).toString());
//
//        HashMap<String, String> a = new HashMap<String, String>();
//        a.put("a", "aa");
//        a.put("b", "bb");
//        a.put("c", "cc");
//
//        System.out.println(a.toString());
//
//        a.put("a", "aaa");
//
//        System.out.println(a.toString());
//</editor-fold>
        
        /*Procedimento p = ProcedimentoController.obter(19);
        p.getDimensao();
        new ExecutarTestes().executarTestes(p, null);*/
        //System.out.println(AtributoAuxController.getNomeTipo(p));
        
        System.out.println("hello");
        System.out.println(String.format("%20s", "oitenta"));
    }
}
